.TH std::numeric_limits::traps 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::numeric_limits::traps \- std::numeric_limits::traps

.SH Synopsis
   static const bool traps;      \fI(until C++11)\fP
   static constexpr bool traps;  \fI(since C++11)\fP

   The value of std::numeric_limits<T>::traps is true for all arithmetic types T that
   have at least one value at the start of the program that, if used as an argument to
   an arithmetic operation, will generate a trap.

.SH Standard specializations

   T                                value of std::numeric_limits<T>::traps
   /* non-specialized */            false
   bool                             false
   char                             usually true
   signed char                      usually true
   unsigned char                    usually true
   wchar_t                          usually true
   char8_t \fI(since C++20)\fP            usually true
   char16_t \fI(since C++11)\fP           usually true
   char32_t \fI(since C++11)\fP           usually true
   short                            usually true
   unsigned short                   usually true
   int                              usually true
   unsigned int                     usually true
   long                             usually true
   unsigned long                    usually true
   long long \fI(since C++11)\fP          usually true
   unsigned long long \fI(since C++11)\fP usually true
   float                            usually false
   double                           usually false
   long double                      usually false

.SH Notes

   On most platforms integer division by zero always traps, and
   std::numeric_limits<T>::traps is true for all integer types that support the value
   0. The exception is the type bool: even though division by false traps due to
   integral promotion from bool to int, it is the zero-valued int that traps. Zero is
   not a value of type bool.

   On most platforms, floating-point exceptions may be turned on and off at run time
   (e.g. feenableexcept() on Linux or _controlfp on Windows), in which case the value
   of std::numeric_limits<T>::traps for floating-point types reflects the state of
   floating-point trapping facility at the time of program startup, which is false on
   most modern systems. An exception would be a DEC Alpha program, where it is true if
   compiled without -ieee.

.SH Example


// Run this code

 #include <iostream>
 #include <limits>

 int main()
 {
     std::cout << std::boolalpha
               << "bool:     traps = " << std::numeric_limits<bool>::traps << '\\n'
               << "char:     traps = " << std::numeric_limits<char>::traps << '\\n'
               << "char16_t: traps = " << std::numeric_limits<char16_t>::traps << '\\n'
               << "long:     traps = " << std::numeric_limits<long>::traps << '\\n'
               << "float:    traps = " << std::numeric_limits<float>::traps << '\\n';
 }

.SH Possible output:

 // GCC output:
 bool:     traps = true
 char:     traps = true
 char16_t: traps = true
 long:     traps = true
 float:    traps = false

 // Clang output:
 bool:     traps = false
 char:     traps = true
 char16_t: traps = true
 long:     traps = true
 float:    traps = false

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

     DR    Applied to         Behavior as published              Correct behavior
                      it was unclear what is returned if    returns the enable status
   LWG 497 C++98      trapping                              at the start of the program
                      is enabled or disabled at runtime

.SH See also

.SH Floating-point environment
   tinyness_before identifies floating-point types that detect tinyness before rounding
   \fB[static]\fP        \fI(public static member constant)\fP
   has_denorm_loss identifies the floating-point types that detect loss of precision as
   \fB[static]\fP        denormalization loss rather than inexact result
                   \fI(public static member constant)\fP
